home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 1843 / 1843.xpi / content / firebug / consoleInjector.js < prev    next >
Text File  |  2010-01-15  |  13KB  |  450 lines
  1. /* See license.txt for terms of usage */
  2.  
  3. //
  4. FBL.ns(function() { with (FBL) {
  5.  
  6. // ************************************************************************************************
  7. // Constants
  8.  
  9. const Cc = Components.classes;
  10. const Ci = Components.interfaces;
  11.  
  12. top.Firebug.Console.injector =
  13. {
  14.     isAttached: function(context, win)
  15.     {
  16.         if (win.wrappedJSObject)
  17.         {
  18.             var attached = (win.wrappedJSObject._getFirebugConsoleElement ? true : false);
  19.             return attached;
  20.         }
  21.         else
  22.         {
  23.             return (win._getFirebugConsoleElement ? true : false);
  24.         }
  25.     },
  26.  
  27.     attachIfNeeded: function(context, win)
  28.     {
  29.         if (this.isAttached(context, win))
  30.             return true;
  31.  
  32.         this.attachConsoleInjector(context, win);
  33.         this.addConsoleListener(context, win);
  34.  
  35.         Firebug.Console.clearReloadWarning(context);
  36.  
  37.         var attached =  this.isAttached(context, win);
  38.         if (attached)
  39.             dispatch(Firebug.Console.fbListeners, "onConsoleInjected", [context, win]);
  40.  
  41.         return attached;
  42.     },
  43.  
  44.     attachConsoleInjector: function(context, win)
  45.     {
  46.         var consoleInjection = this.getConsoleInjectionScript();  // Do it all here.
  47.  
  48.         Firebug.CommandLine.evaluateInWebPage(consoleInjection, context, win);
  49.  
  50.     },
  51.  
  52.     getConsoleInjectionScript: function() {
  53.         if (!this.consoleInjectionScript)
  54.         {
  55.             var script = "";
  56.             script += "window.__defineGetter__('console', function() {\n";
  57.             script += " return (window._firebug ? window._firebug : window.loadFirebugConsole()); })\n\n";
  58.  
  59.             script += "window.loadFirebugConsole = function() {\n";
  60.             script += "window._firebug =  new _FirebugConsole();";
  61.  
  62.             script += " return window._firebug };\n";
  63.  
  64.             var theFirebugConsoleScript = getResource("chrome://firebug/content/consoleInjected.js");
  65.             script += theFirebugConsoleScript;
  66.  
  67.  
  68.             this.consoleInjectionScript = script;
  69.         }
  70.         return this.consoleInjectionScript;
  71.     },
  72.  
  73.     forceConsoleCompilationInPage: function(context, win)
  74.     {
  75.         if (!win)
  76.         {
  77.             return;
  78.         }
  79.  
  80.         var consoleForcer = "window.loadFirebugConsole();";
  81.  
  82.         if (context.stopped)
  83.             Firebug.Console.injector.evaluateConsoleScript(context);  // todo evaluate consoleForcer on stack
  84.         else
  85.             Firebug.CommandLine.evaluateInWebPage(consoleForcer, context, win);
  86.  
  87.     },
  88.  
  89.     evaluateConsoleScript: function(context)
  90.     {
  91.         var scriptSource = this.getConsoleInjectionScript(); // TODO XXXjjb this should be getConsoleInjectionScript
  92.         Firebug.Debugger.evaluate(scriptSource, context);
  93.     },
  94.  
  95.     addConsoleListener: function(context, win)
  96.     {
  97.         if (!context.activeConsoleHandlers)  // then we have not been this way before
  98.             context.activeConsoleHandlers = [];
  99.         else
  100.         {   // we've been this way before...
  101.             for (var i=0; i<context.activeConsoleHandlers.length; i++)
  102.             {
  103.                 if (context.activeConsoleHandlers[i].window == win)
  104.                 {
  105.                     context.activeConsoleHandlers[i].detach();
  106.                     context.activeConsoleHandlers.splice(i,1);
  107.                 }
  108.             }
  109.         }
  110.  
  111.         // We need the element to attach our event listener.
  112.         var element = Firebug.Console.getFirebugConsoleElement(context, win);
  113.         if (element)
  114.             element.setAttribute("FirebugVersion", Firebug.version); // Initialize Firebug version.
  115.         else
  116.             return false;
  117.  
  118.         var handler = new FirebugConsoleHandler(context, win);
  119.         handler.attachTo(element);
  120.  
  121.         context.activeConsoleHandlers.push(handler);
  122.  
  123.         return true;
  124.     },
  125.  
  126.     detachConsole: function(context, win)
  127.     {
  128.         if (win && win.document)
  129.         {
  130.             var element = win.document.getElementById("_firebugConsole");
  131.             if (element)
  132.                 element.parentNode.removeChild(element);
  133.         }
  134.     },
  135. }
  136.  
  137. var total_handlers = 0;
  138. function FirebugConsoleHandler(context, win)
  139. {
  140.     this.window = win;
  141.  
  142.     this.attachTo = function(element)
  143.     {
  144.         this.element = element;
  145.         // When raised on our injected element, callback to Firebug and append to console
  146.         this.boundHandler = bind(this.handleEvent, this);
  147.         this.element.addEventListener('firebugAppendConsole', this.boundHandler, true); // capturing
  148.     };
  149.  
  150.     this.detach = function()
  151.     {
  152.         this.element.removeEventListener('firebugAppendConsole', this.boundHandler, true);
  153.     };
  154.  
  155.     this.handler_name = ++total_handlers;
  156.     this.handleEvent = function(event)
  157.     {
  158.         if (!Firebug.CommandLine.CommandHandler.handle(event, this, win))
  159.         {
  160.             var methodName = event.target.getAttribute("methodName");
  161.             Firebug.Console.log($STRF("console.MethodNotSupported", [methodName]));
  162.         }
  163.     };
  164.  
  165.     this.firebug = Firebug.version;
  166.  
  167.     this.init = function()
  168.     {
  169.         var consoleElement = win.document.getElementById('_firebugConsole');
  170.         consoleElement.setAttribute("FirebugVersion", Firebug.version);
  171.     };
  172.  
  173.     this.log = function()
  174.     {
  175.         logFormatted(arguments, "log");
  176.     };
  177.  
  178.     this.debug = function()
  179.     {
  180.         logFormatted(arguments, "debug", true);
  181.     };
  182.  
  183.     this.info = function()
  184.     {
  185.         logFormatted(arguments, "info", true);
  186.     };
  187.  
  188.     this.warn = function()
  189.     {
  190.         logFormatted(arguments, "warn", true);
  191.     };
  192.  
  193.     this.error = function()
  194.     {
  195.         if (arguments.length == 1)
  196.         {
  197.             logAssert("error", arguments);  // add more info based on stack trace
  198.         }
  199.         else
  200.         {
  201.             Firebug.Errors.increaseCount(context);
  202.             logFormatted(arguments, "error", true);  // user already added info
  203.         }
  204.     };
  205.  
  206.     this.exception = function()
  207.     {
  208.         logAssert("error", arguments);
  209.     };
  210.  
  211.     this.assert = function(x)
  212.     {
  213.         if (!x)
  214.         {
  215.             var rest = [];
  216.             for (var i = 1; i < arguments.length; i++)
  217.                 rest.push(arguments[i]);
  218.             logAssert("assert", rest);
  219.         }
  220.     };
  221.  
  222.     this.dir = function(o)
  223.     {
  224.         Firebug.Console.log(o, context, "dir", Firebug.DOMPanel.DirTable);
  225.     };
  226.  
  227.     this.dirxml = function(o)
  228.     {
  229.         if (o instanceof Window)
  230.             o = o.document.documentElement;
  231.         else if (o instanceof Document)
  232.             o = o.documentElement;
  233.  
  234.         Firebug.Console.log(o, context, "dirxml", Firebug.HTMLPanel.SoloElement);
  235.     };
  236.  
  237.     this.group = function()
  238.     {
  239.         var sourceLink = getStackLink();
  240.         Firebug.Console.openGroup(arguments, null, "group", null, false, sourceLink);
  241.     };
  242.  
  243.     this.groupEnd = function()
  244.     {
  245.         Firebug.Console.closeGroup(context);
  246.     };
  247.  
  248.     this.groupCollapsed = function()
  249.     {
  250.         var sourceLink = getStackLink();
  251.         // noThrottle true is probably ok, openGroups will likely be short strings.
  252.         var row = Firebug.Console.openGroup(arguments, null, "group", null, true, sourceLink);
  253.         removeClass(row, "opened");
  254.     };
  255.  
  256.     this.profile = function(title)
  257.     {
  258.         Firebug.Profiler.startProfiling(context, title);
  259.     };
  260.  
  261.     this.profileEnd = function()
  262.     {
  263.         Firebug.Profiler.stopProfiling(context);
  264.     };
  265.  
  266.     this.count = function(key)
  267.     {
  268.         var frameId = FBL.getStackFrameId();
  269.         if (frameId)
  270.         {
  271.             if (!context.frameCounters)
  272.                 context.frameCounters = {};
  273.  
  274.             if (key != undefined)
  275.                 frameId += key;
  276.  
  277.             var frameCounter = context.frameCounters[frameId];
  278.             if (!frameCounter)
  279.             {
  280.                 var logRow = logFormatted(["0"], null, true, true);
  281.  
  282.                 frameCounter = {logRow: logRow, count: 1};
  283.                 context.frameCounters[frameId] = frameCounter;
  284.             }
  285.             else
  286.                 ++frameCounter.count;
  287.  
  288.             var label = key == undefined
  289.                 ? frameCounter.count
  290.                 : key + " " + frameCounter.count;
  291.  
  292.             frameCounter.logRow.firstChild.firstChild.nodeValue = label;
  293.         }
  294.     };
  295.  
  296.     this.clear = function()
  297.     {
  298.         Firebug.Console.clear(context);
  299.     };
  300.  
  301.     this.time = function(name, reset)
  302.     {
  303.         if (!name)
  304.             return;
  305.  
  306.         var time = new Date().getTime();
  307.  
  308.         if (!this.timeCounters)
  309.             this.timeCounters = {};
  310.  
  311.         var key = "KEY"+name.toString();
  312.  
  313.         if (!reset && this.timeCounters[key])
  314.             return;
  315.  
  316.         this.timeCounters[key] = time;
  317.     };
  318.  
  319.     this.timeEnd = function(name)
  320.     {
  321.         var time = new Date().getTime();
  322.  
  323.         if (!this.timeCounters)
  324.             return;
  325.  
  326.         var key = "KEY"+name.toString();
  327.  
  328.         var timeCounter = this.timeCounters[key];
  329.         if (timeCounter)
  330.         {
  331.             var diff = time - timeCounter;
  332.             var label = name + ": " + diff + "ms";
  333.  
  334.             this.info(label);
  335.  
  336.             delete this.timeCounters[key];
  337.         }
  338.         return diff;
  339.     };
  340.  
  341.     // These functions are over-ridden by commandLine
  342.     this.evaluated = function(result, context)
  343.     {
  344.         Firebug.Console.log(result, context);
  345.     };
  346.     this.evaluateError = function(result, context)
  347.     {
  348.         Firebug.Console.log(result, context, "errorMessage");
  349.     };
  350.  
  351.     // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  352.  
  353.     function logFormatted(args, className, linkToSource, noThrottle)
  354.     {
  355.         var sourceLink = linkToSource ? getStackLink() : null;
  356.         return Firebug.Console.logFormatted(args, context, className, noThrottle, sourceLink);
  357.     }
  358.  
  359.     function logAssert(category, args)
  360.     {
  361.         Firebug.Errors.increaseCount(context);
  362.  
  363.         if (!args || !args.length || args.length == 0)
  364.             var msg = [FBL.$STR("Assertion")];
  365.         else
  366.             var msg = args[0];
  367.  
  368.         if (Firebug.errorStackTrace)
  369.         {
  370.             var trace = Firebug.errorStackTrace;
  371.             delete Firebug.errorStackTrace;
  372.         }
  373.         else if (msg.stack)
  374.         {
  375.             var trace = parseToStackTrace(msg.stack);
  376.         }
  377.         else
  378.         {
  379.             var trace = getJSDUserStack();
  380.         }
  381.  
  382.         var errorObject = new FBL.ErrorMessage(msg, (msg.fileName?msg.fileName:win.location), (msg.lineNumber?msg.lineNumber:0), "", category, context, trace);
  383.  
  384.  
  385.         if (trace && trace.frames && trace.frames[0])
  386.            errorObject.correctWithStackTrace(trace);
  387.  
  388.         errorObject.resetSource();
  389.  
  390.         var objects = errorObject;
  391.         if (args.length > 1)
  392.         {
  393.             objects = [errorObject];
  394.             for (var i = 1; i < args.length; i++)
  395.                 objects.push(args[i]);
  396.         }
  397.  
  398.         var row = Firebug.Console.log(objects, context, "errorMessage", null, true); // noThrottle
  399.         row.scrollIntoView();
  400.     }
  401.  
  402.     function getComponentsStackDump()
  403.     {
  404.         // Starting with our stack, walk back to the user-level code
  405.         var frame = Components.stack;
  406.         var userURL = win.location.href.toString();
  407.  
  408.         while (frame && FBL.isSystemURL(frame.filename) )
  409.             frame = frame.caller;
  410.  
  411.         // Drop two more frames, the injected console function and firebugAppendConsole()
  412.         if (frame)
  413.             frame = frame.caller;
  414.         if (frame)
  415.             frame = frame.caller;
  416.  
  417.         return frame;
  418.     }
  419.  
  420.     function getStackLink()
  421.     {
  422.         return FBL.getFrameSourceLink(getComponentsStackDump());
  423.     }
  424.  
  425.     function getJSDUserStack()
  426.     {
  427.         var trace = FBL.getCurrentStackTrace(context);
  428.  
  429.         var frames = trace ? trace.frames : null;
  430.         if (frames && (frames.length > 0) )
  431.         {
  432.             var oldest = frames.length - 1;  // 6 - 1 = 5
  433.             for (var i = 0; i < frames.length; i++)
  434.             {
  435.                 if (frames[oldest - i].href.indexOf("chrome:") == 0) break;
  436.                 var fn = frames[oldest - i].fn + "";
  437.                 if (fn && (fn.indexOf("_firebugEvalEvent") != -1) ) break;  // command line
  438.             }
  439.             FBTrace.sysout("consoleInjector getJSDUserStack: "+frames.length+" oldest: "+oldest+" i: "+i+" i - oldest + 2: "+(i - oldest + 2), trace);
  440.             trace.frames = trace.frames.slice(2 - i);  // take the oldest frames, leave 2 behind they are injection code
  441.  
  442.             return trace;
  443.         }
  444.         else
  445.             return "Firebug failed to get stack trace with any frames";
  446.     }
  447. }
  448.  
  449. }});
  450.